home *** CD-ROM | disk | FTP | other *** search
/ Sky at Night 2007 June / SAN CD 6-2007 CD-ROM 25.iso / pc / Software / AstroGrav_Win / Java / jre1.6.0 / lib / rt.jar / java / awt / MultipleGradientPaintContext.class (.txt) < prev    next >
Encoding:
Java Class File  |  2006-11-29  |  6.2 KB  |  366 lines
  1. package java.awt;
  2.  
  3. import java.awt.MultipleGradientPaint.ColorSpaceType;
  4. import java.awt.MultipleGradientPaint.CycleMethod;
  5. import java.awt.geom.AffineTransform;
  6. import java.awt.geom.NoninvertibleTransformException;
  7. import java.awt.geom.Rectangle2D;
  8. import java.awt.image.ColorModel;
  9. import java.awt.image.DataBufferInt;
  10. import java.awt.image.DirectColorModel;
  11. import java.awt.image.Raster;
  12. import java.awt.image.SinglePixelPackedSampleModel;
  13. import java.lang.ref.SoftReference;
  14. import java.lang.ref.WeakReference;
  15.  
  16. abstract class MultipleGradientPaintContext implements PaintContext {
  17.    protected ColorModel model;
  18.    private static ColorModel xrgbmodel = new DirectColorModel(24, 16711680, 65280, 255);
  19.    protected static ColorModel cachedModel;
  20.    protected static WeakReference<Raster> cached;
  21.    protected Raster saved;
  22.    protected MultipleGradientPaint.CycleMethod cycleMethod;
  23.    protected MultipleGradientPaint.ColorSpaceType colorSpace;
  24.    protected float a00;
  25.    protected float a01;
  26.    protected float a10;
  27.    protected float a11;
  28.    protected float a02;
  29.    protected float a12;
  30.    protected boolean isSimpleLookup;
  31.    protected int fastGradientArraySize;
  32.    protected int[] gradient;
  33.    private int[][] gradients;
  34.    private float[] normalizedIntervals;
  35.    private float[] fractions;
  36.    private int transparencyTest;
  37.    private static final int[] SRGBtoLinearRGB = new int[256];
  38.    private static final int[] LinearRGBtoSRGB = new int[256];
  39.    protected static final int GRADIENT_SIZE = 256;
  40.    protected static final int GRADIENT_SIZE_INDEX = 255;
  41.    private static final int MAX_GRADIENT_ARRAY_SIZE = 5000;
  42.  
  43.    protected MultipleGradientPaintContext(MultipleGradientPaint var1, ColorModel var2, Rectangle var3, Rectangle2D var4, AffineTransform var5, RenderingHints var6, float[] var7, Color[] var8, MultipleGradientPaint.CycleMethod var9, MultipleGradientPaint.ColorSpaceType var10) {
  44.       if (var3 == null) {
  45.          throw new NullPointerException("Device bounds cannot be null");
  46.       } else if (var4 == null) {
  47.          throw new NullPointerException("User bounds cannot be null");
  48.       } else if (var5 == null) {
  49.          throw new NullPointerException("Transform cannot be null");
  50.       } else if (var6 == null) {
  51.          throw new NullPointerException("RenderingHints cannot be null");
  52.       } else {
  53.          AffineTransform var11;
  54.          try {
  55.             var5.invert();
  56.             var11 = var5;
  57.          } catch (NoninvertibleTransformException var15) {
  58.             var11 = new AffineTransform();
  59.          }
  60.  
  61.          double[] var12 = new double[6];
  62.          var11.getMatrix(var12);
  63.          this.a00 = (float)var12[0];
  64.          this.a10 = (float)var12[1];
  65.          this.a01 = (float)var12[2];
  66.          this.a11 = (float)var12[3];
  67.          this.a02 = (float)var12[4];
  68.          this.a12 = (float)var12[5];
  69.          this.cycleMethod = var9;
  70.          this.colorSpace = var10;
  71.          this.fractions = var7;
  72.          int[] var13 = var1.gradient != null ? (int[])var1.gradient.get() : null;
  73.          int[][] var14 = var1.gradients != null ? (int[][])var1.gradients.get() : (int[][])null;
  74.          if (var13 == null && var14 == null) {
  75.             this.calculateLookupData(var8);
  76.             var1.model = this.model;
  77.             var1.normalizedIntervals = this.normalizedIntervals;
  78.             var1.isSimpleLookup = this.isSimpleLookup;
  79.             if (this.isSimpleLookup) {
  80.                var1.fastGradientArraySize = this.fastGradientArraySize;
  81.                var1.gradient = new SoftReference(this.gradient);
  82.             } else {
  83.                var1.gradients = new SoftReference(this.gradients);
  84.             }
  85.          } else {
  86.             this.model = var1.model;
  87.             this.normalizedIntervals = var1.normalizedIntervals;
  88.             this.isSimpleLookup = var1.isSimpleLookup;
  89.             this.gradient = var13;
  90.             this.fastGradientArraySize = var1.fastGradientArraySize;
  91.             this.gradients = var14;
  92.          }
  93.  
  94.       }
  95.    }
  96.  
  97.    private void calculateLookupData(Color[] var1) {
  98.       Color[] var2;
  99.       if (this.colorSpace == ColorSpaceType.LINEAR_RGB) {
  100.          var2 = new Color[var1.length];
  101.  
  102.          for(int var3 = 0; var3 < var1.length; ++var3) {
  103.             int var4 = var1[var3].getRGB();
  104.             int var5 = var4 >>> 24;
  105.             int var6 = SRGBtoLinearRGB[var4 >> 16 & 255];
  106.             int var7 = SRGBtoLinearRGB[var4 >> 8 & 255];
  107.             int var8 = SRGBtoLinearRGB[var4 & 255];
  108.             var2[var3] = new Color(var6, var7, var8, var5);
  109.          }
  110.       } else {
  111.          var2 = var1;
  112.       }
  113.  
  114.       this.normalizedIntervals = new float[this.fractions.length - 1];
  115.  
  116.       for(int var9 = 0; var9 < this.normalizedIntervals.length; ++var9) {
  117.          this.normalizedIntervals[var9] = this.fractions[var9 + 1] - this.fractions[var9];
  118.       }
  119.  
  120.       this.transparencyTest = -16777216;
  121.       this.gradients = new int[this.normalizedIntervals.length][];
  122.       float var10 = 1.0F;
  123.  
  124.       for(int var11 = 0; var11 < this.normalizedIntervals.length; ++var11) {
  125.          var10 = var10 > this.normalizedIntervals[var11] ? this.normalizedIntervals[var11] : var10;
  126.       }
  127.  
  128.       int var12 = 0;
  129.  
  130.       for(int var13 = 0; var13 < this.normalizedIntervals.length; ++var13) {
  131.          var12 = (int)((float)var12 + this.normalizedIntervals[var13] / var10 * 256.0F);
  132.       }
  133.  
  134.       if (var12 > 5000) {
  135.          this.calculateMultipleArrayGradient(var2);
  136.       } else {
  137.          this.calculateSingleArrayGradient(var2, var10);
  138.       }
  139.  
  140.       if (this.transparencyTest >>> 24 == 255) {
  141.          this.model = xrgbmodel;
  142.       } else {
  143.          this.model = ColorModel.getRGBdefault();
  144.       }
  145.  
  146.    }
  147.  
  148.    private void calculateSingleArrayGradient(Color[] var1, float var2) {
  149.       this.isSimpleLookup = true;
  150.       int var5 = 1;
  151.  
  152.       for(int var6 = 0; var6 < this.gradients.length; ++var6) {
  153.          int var7 = (int)(this.normalizedIntervals[var6] / var2 * 255.0F);
  154.          var5 += var7;
  155.          this.gradients[var6] = new int[var7];
  156.          int var3 = var1[var6].getRGB();
  157.          int var4 = var1[var6 + 1].getRGB();
  158.          this.interpolate(var3, var4, this.gradients[var6]);
  159.          this.transparencyTest &= var3;
  160.          this.transparencyTest &= var4;
  161.       }
  162.  
  163.       this.gradient = new int[var5];
  164.       int var8 = 0;
  165.  
  166.       for(int var9 = 0; var9 < this.gradients.length; ++var9) {
  167.          System.arraycopy(this.gradients[var9], 0, this.gradient, var8, this.gradients[var9].length);
  168.          var8 += this.gradients[var9].length;
  169.       }
  170.  
  171.       this.gradient[this.gradient.length - 1] = var1[var1.length - 1].getRGB();
  172.       if (this.colorSpace == ColorSpaceType.LINEAR_RGB) {
  173.          for(int var10 = 0; var10 < this.gradient.length; ++var10) {
  174.             this.gradient[var10] = this.convertEntireColorLinearRGBtoSRGB(this.gradient[var10]);
  175.          }
  176.       }
  177.  
  178.       this.fastGradientArraySize = this.gradient.length - 1;
  179.    }
  180.  
  181.    private void calculateMultipleArrayGradient(Color[] var1) {
  182.       this.isSimpleLookup = false;
  183.  
  184.       for(int var4 = 0; var4 < this.gradients.length; ++var4) {
  185.          this.gradients[var4] = new int[256];
  186.          int var2 = var1[var4].getRGB();
  187.          int var3 = var1[var4 + 1].getRGB();
  188.          this.interpolate(var2, var3, this.gradients[var4]);
  189.          this.transparencyTest &= var2;
  190.          this.transparencyTest &= var3;
  191.       }
  192.  
  193.       if (this.colorSpace == ColorSpaceType.LINEAR_RGB) {
  194.          for(int var6 = 0; var6 < this.gradients.length; ++var6) {
  195.             for(int var5 = 0; var5 < this.gradients[var6].length; ++var5) {
  196.                this.gradients[var6][var5] = this.convertEntireColorLinearRGBtoSRGB(this.gradients[var6][var5]);
  197.             }
  198.          }
  199.       }
  200.  
  201.    }
  202.  
  203.    private void interpolate(int var1, int var2, int[] var3) {
  204.       float var12 = 1.0F / (float)var3.length;
  205.       int var4 = var1 >> 24 & 255;
  206.       int var5 = var1 >> 16 & 255;
  207.       int var6 = var1 >> 8 & 255;
  208.       int var7 = var1 & 255;
  209.       int var8 = (var2 >> 24 & 255) - var4;
  210.       int var9 = (var2 >> 16 & 255) - var5;
  211.       int var10 = (var2 >> 8 & 255) - var6;
  212.       int var11 = (var2 & 255) - var7;
  213.  
  214.       for(int var13 = 0; var13 < var3.length; ++var13) {
  215.          var3[var13] = (int)((double)((float)var4 + (float)(var13 * var8) * var12) + (double)0.5F) << 24 | (int)((double)((float)var5 + (float)(var13 * var9) * var12) + (double)0.5F) << 16 | (int)((double)((float)var6 + (float)(var13 * var10) * var12) + (double)0.5F) << 8 | (int)((double)((float)var7 + (float)(var13 * var11) * var12) + (double)0.5F);
  216.       }
  217.  
  218.    }
  219.  
  220.    private int convertEntireColorLinearRGBtoSRGB(int var1) {
  221.       int var2 = var1 >> 24 & 255;
  222.       int var3 = var1 >> 16 & 255;
  223.       int var4 = var1 >> 8 & 255;
  224.       int var5 = var1 & 255;
  225.       var3 = LinearRGBtoSRGB[var3];
  226.       var4 = LinearRGBtoSRGB[var4];
  227.       var5 = LinearRGBtoSRGB[var5];
  228.       return var2 << 24 | var3 << 16 | var4 << 8 | var5;
  229.    }
  230.  
  231.    protected final int indexIntoGradientsArrays(float var1) {
  232.       if (this.cycleMethod == CycleMethod.NO_CYCLE) {
  233.          if (var1 > 1.0F) {
  234.             var1 = 1.0F;
  235.          } else if (var1 < 0.0F) {
  236.             var1 = 0.0F;
  237.          }
  238.       } else if (this.cycleMethod == CycleMethod.REPEAT) {
  239.          var1 -= (float)((int)var1);
  240.          if (var1 < 0.0F) {
  241.             ++var1;
  242.          }
  243.       } else {
  244.          if (var1 < 0.0F) {
  245.             var1 = -var1;
  246.          }
  247.  
  248.          int var2 = (int)var1;
  249.          var1 -= (float)var2;
  250.          if ((var2 & 1) == 1) {
  251.             var1 = 1.0F - var1;
  252.          }
  253.       }
  254.  
  255.       if (this.isSimpleLookup) {
  256.          return this.gradient[(int)(var1 * (float)this.fastGradientArraySize)];
  257.       } else {
  258.          for(int var5 = 0; var5 < this.gradients.length; ++var5) {
  259.             if (var1 < this.fractions[var5 + 1]) {
  260.                float var3 = var1 - this.fractions[var5];
  261.                int var4 = (int)(var3 / this.normalizedIntervals[var5] * 255.0F);
  262.                return this.gradients[var5][var4];
  263.             }
  264.          }
  265.  
  266.          return this.gradients[this.gradients.length - 1][255];
  267.       }
  268.    }
  269.  
  270.    private static int convertSRGBtoLinearRGB(int var0) {
  271.       float var1 = (float)var0 / 255.0F;
  272.       float var2;
  273.       if (var1 <= 0.04045F) {
  274.          var2 = var1 / 12.92F;
  275.       } else {
  276.          var2 = (float)Math.pow(((double)var1 + 0.055) / 1.055, 2.4);
  277.       }
  278.  
  279.       return Math.round(var2 * 255.0F);
  280.    }
  281.  
  282.    private static int convertLinearRGBtoSRGB(int var0) {
  283.       float var1 = (float)var0 / 255.0F;
  284.       float var2;
  285.       if ((double)var1 <= 0.0031308) {
  286.          var2 = var1 * 12.92F;
  287.       } else {
  288.          var2 = 1.055F * (float)Math.pow((double)var1, 0.4166666666666667) - 0.055F;
  289.       }
  290.  
  291.       return Math.round(var2 * 255.0F);
  292.    }
  293.  
  294.    public final Raster getRaster(int var1, int var2, int var3, int var4) {
  295.       Raster var5 = this.saved;
  296.       if (var5 == null || var5.getWidth() < var3 || var5.getHeight() < var4) {
  297.          var5 = getCachedRaster(this.model, var3, var4);
  298.          this.saved = var5;
  299.       }
  300.  
  301.       DataBufferInt var6 = (DataBufferInt)var5.getDataBuffer();
  302.       int[] var7 = var6.getBankData()[0];
  303.       int var8 = var6.getOffset();
  304.       int var9 = ((SinglePixelPackedSampleModel)var5.getSampleModel()).getScanlineStride();
  305.       int var10 = var9 - var3;
  306.       this.fillRaster(var7, var8, var10, var1, var2, var3, var4);
  307.       return var5;
  308.    }
  309.  
  310.    protected abstract void fillRaster(int[] var1, int var2, int var3, int var4, int var5, int var6, int var7);
  311.  
  312.    private static synchronized Raster getCachedRaster(ColorModel var0, int var1, int var2) {
  313.       if (var0 == cachedModel && cached != null) {
  314.          Raster var3 = (Raster)cached.get();
  315.          if (var3 != null && var3.getWidth() >= var1 && var3.getHeight() >= var2) {
  316.             cached = null;
  317.             return var3;
  318.          }
  319.       }
  320.  
  321.       return var0.createCompatibleWritableRaster(var1, var2);
  322.    }
  323.  
  324.    private static synchronized void putCachedRaster(ColorModel var0, Raster var1) {
  325.       if (cached != null) {
  326.          Raster var2 = (Raster)cached.get();
  327.          if (var2 != null) {
  328.             int var3 = var2.getWidth();
  329.             int var4 = var2.getHeight();
  330.             int var5 = var1.getWidth();
  331.             int var6 = var1.getHeight();
  332.             if (var3 >= var5 && var4 >= var6) {
  333.                return;
  334.             }
  335.  
  336.             if (var3 * var4 >= var5 * var6) {
  337.                return;
  338.             }
  339.          }
  340.       }
  341.  
  342.       cachedModel = var0;
  343.       cached = new WeakReference(var1);
  344.    }
  345.  
  346.    public final void dispose() {
  347.       if (this.saved != null) {
  348.          putCachedRaster(this.model, this.saved);
  349.          this.saved = null;
  350.       }
  351.  
  352.    }
  353.  
  354.    public final ColorModel getColorModel() {
  355.       return this.model;
  356.    }
  357.  
  358.    static {
  359.       for(int var0 = 0; var0 < 256; ++var0) {
  360.          SRGBtoLinearRGB[var0] = convertSRGBtoLinearRGB(var0);
  361.          LinearRGBtoSRGB[var0] = convertLinearRGBtoSRGB(var0);
  362.       }
  363.  
  364.    }
  365. }
  366.